using System; 
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq.Expressions; 
using System.Reflection;
using System.Text; 
using System.Linq; 
using System.Runtime.CompilerServices;
 
namespace System.Data.Linq {
    using System.Data.Linq.Mapping;
    using System.Data.Linq.Provider;
 
    internal class CommonDataServices : IDataServices {
        DataContext context; 
        MetaModel metaModel; 
        IdentityManager identifier;
        ChangeTracker tracker; 
        ChangeDirector director;
        bool hasCachedObjects;
        Dictionary<MetaDataMember, IDeferredSourceFactory> factoryMap;
 
        internal CommonDataServices(DataContext context, MetaModel model) {
            this.context = context; 
            this.metaModel = model; 
            bool asReadOnly = !context.ObjectTrackingEnabled;
            this.identifier = IdentityManager.CreateIdentityManager(asReadOnly); 
            this.tracker = ChangeTracker.CreateChangeTracker(this, asReadOnly);
            this.director = ChangeDirector.CreateChangeDirector(context);
            this.factoryMap = new Dictionary<MetaDataMember, IDeferredSourceFactory>();
        } 

        public DataContext Context { 
            get { return this.context; } 
        }
 
        public MetaModel Model {
            get { return this.metaModel; }
        }
 
        internal void SetModel(MetaModel model) {
            this.metaModel = model; 
        } 

        internal IdentityManager IdentityManager { 
            get { return this.identifier; }
        }

        internal ChangeTracker ChangeTracker { 
            get { return this.tracker; }
        } 
 
        internal ChangeDirector ChangeDirector {
            get { return this.director; } 
        }

        internal IEnumerable<RelatedItem> GetParents(MetaType type, object item) {
            return this.GetRelations(type, item, true); 
        }
 
        internal IEnumerable<RelatedItem> GetChildren(MetaType type, object item) { 
            return this.GetRelations(type, item, false);
        } 

        private IEnumerable<RelatedItem> GetRelations(MetaType type, object item, bool isForeignKey) {
            foreach (MetaDataMember mm in type.PersistentDataMembers) {
                if (mm.IsAssociation) { 
                    MetaType otherType = mm.Association.OtherType;
                    if (mm.Association.IsForeignKey == isForeignKey) { 
                        object value = null; 
                        if (mm.IsDeferred) {
                            value = mm.DeferredValueAccessor.GetBoxedValue(item); 
                        }
                        else {
                            value = mm.StorageAccessor.GetBoxedValue(item);
                        } 
                        if (value != null) {
                            if (mm.Association.IsMany) { 
                                IEnumerable list = (IEnumerable)value; 
                                foreach (object otherItem in list) {
                                    yield return new RelatedItem(otherType.GetInheritanceType(otherItem.GetType()), otherItem); 
                                }
                            }
                            else {
                                yield return new RelatedItem(otherType.GetInheritanceType(value.GetType()), value); 
                            }
                        } 
                    } 
                }
            } 
        }

        internal void ResetServices() {
            hasCachedObjects = false; 
            bool asReadOnly = !context.ObjectTrackingEnabled;
            this.identifier = IdentityManager.CreateIdentityManager(asReadOnly); 
            this.tracker = ChangeTracker.CreateChangeTracker(this, asReadOnly); 
            this.factoryMap = new Dictionary<MetaDataMember, IDeferredSourceFactory>();
        } 

        internal static object[] GetKeyValues(MetaType type, object instance) {
            List<object> keyValues = new List<object>();
            foreach (MetaDataMember mm in type.IdentityMembers) { 
                keyValues.Add(mm.MemberAccessor.GetBoxedValue(instance));
            } 
            return keyValues.ToArray(); 
        }
 
        internal static object[] GetForeignKeyValues(MetaAssociation association, object instance) {
            List<object> keyValues = new List<object>();
            foreach(MetaDataMember mm in association.ThisKey) {
                keyValues.Add(mm.MemberAccessor.GetBoxedValue(instance)); 
            }
            return keyValues.ToArray(); 
        } 

        internal object GetCachedObject(MetaType type, object[] keyValues) { 
            if( type == null ) {
                throw Error.ArgumentNull("type");
            }
            if (!type.IsEntity) { 
                return null;
            } 
            return this.identifier.Find(type, keyValues); 
        }
 
        internal object GetCachedObjectLike(MetaType type, object instance) {
            if( type == null ) {
                throw Error.ArgumentNull("type");
            } 
            if (!type.IsEntity) {
                return null; 
            } 
            return this.identifier.FindLike(type, instance);
        } 

        public bool IsCachedObject(MetaType type, object instance) {
            if( type == null ) {
                throw Error.ArgumentNull("type"); 
            }
            if (!type.IsEntity) { 
                return false; 
            }
            return this.identifier.FindLike(type, instance) == instance; 
        }

        public object InsertLookupCachedObject(MetaType type, object instance) {
            if( type == null ) { 
                throw Error.ArgumentNull("type");
            } 
            hasCachedObjects = true;  // flag that we have cached objects 
            if (!type.IsEntity) {
                return instance; 
            }
            return this.identifier.InsertLookup(type, instance);
        }
 
        public bool RemoveCachedObjectLike(MetaType type, object instance) {
            if (type == null) { 
                throw Error.ArgumentNull("type"); 
            }
            if (!type.IsEntity) { 
                return false;
            }
            return this.identifier.RemoveLike(type, instance);
        } 

        public void OnEntityMaterialized(MetaType type, object instance) { 
            if (type == null) { 
                throw Error.ArgumentNull("type");
            } 
            this.tracker.FastTrack(instance);

            if (type.HasAnyLoadMethod) {
                SendOnLoaded(type, instance); 
            }
        } 
 
        private static void SendOnLoaded(MetaType type, object item) {
            if (type != null) { 
                SendOnLoaded(type.InheritanceBase, item);

                if (type.OnLoadedMethod != null) {
                    try { 
                        type.OnLoadedMethod.Invoke(item, new object[] { });
                    } catch (TargetInvocationException tie) { 
                        if (tie.InnerException != null) { 
                            throw tie.InnerException;
                        } 

                        throw;
                    }
                } 
            }
        } 
 

        /// <summary> 
        /// Returns a query for the entity indicated by the specified key.
        /// </summary>
        internal Expression GetObjectQuery(MetaType type, object[] keyValues) {
            if (type == null) { 
                throw Error.ArgumentNull("type");
            } 
            if (keyValues == null) { 
                throw Error.ArgumentNull("keyValues");
            } 
            return this.GetObjectQuery(type, BuildKeyExpressions(keyValues, type.IdentityMembers));
        }

        internal Expression GetObjectQuery(MetaType type, Expression[] keyValues) { 
            ITable table = this.context.GetTable(type.InheritanceRoot.Type);
            ParameterExpression serverItem = Expression.Parameter(table.ElementType, "p"); 
 
            // create a where expression including all the identity members
            Expression whereExpression = null; 
            for (int i = 0, n = type.IdentityMembers.Count; i < n; i++) {
                MetaDataMember metaMember = type.IdentityMembers[i];
                Expression memberExpression = (metaMember.Member is FieldInfo)
                    ? Expression.Field(serverItem, (FieldInfo)metaMember.Member) 
                    : Expression.Property(serverItem, (PropertyInfo)metaMember.Member);
                Expression memberEqualityExpression = Expression.Equal(memberExpression, keyValues[i]); 
                whereExpression = (whereExpression != null) 
                    ? Expression.And(whereExpression, memberEqualityExpression)
                    : memberEqualityExpression; 
            }
            return Expression.Call(typeof(Queryable), "Where", new Type[] { table.ElementType }, table.Expression, Expression.Lambda(whereExpression, serverItem));
        }
 
        internal Expression GetDataMemberQuery(MetaDataMember member, Expression[] keyValues) {
            if (member == null) 
                throw Error.ArgumentNull("member"); 
            if (keyValues == null)
                throw Error.ArgumentNull("keyValues"); 
            if (member.IsAssociation) {
                MetaAssociation association = member.Association;
                Type rootType = association.ThisMember.DeclaringType.InheritanceRoot.Type;
                Expression thisSource = Expression.Constant(context.GetTable(rootType)); 
                if (rootType != association.ThisMember.DeclaringType.Type) {
                    thisSource = Expression.Call(typeof(Enumerable), "Cast", new Type[] { association.ThisMember.DeclaringType.Type }, thisSource); 
                } 
                Expression thisInstance = Expression.Call(typeof(Enumerable), "FirstOrDefault", new Type[] { association.ThisMember.DeclaringType.Type },
                    System.Data.Linq.SqlClient.Translator.WhereClauseFromSourceAndKeys(thisSource, association.ThisKey.ToArray(), keyValues) 
                    );
                Expression otherSource = Expression.Constant(context.GetTable(association.OtherType.InheritanceRoot.Type));
                if (association.OtherType.Type!=association.OtherType.InheritanceRoot.Type) {
                    otherSource = Expression.Call(typeof(Enumerable), "Cast", new Type[] { association.OtherType.Type }, otherSource); 
                }
                Expression expr = System.Data.Linq.SqlClient.Translator.TranslateAssociation( 
                    this.context, association, otherSource, keyValues, thisInstance 
                    );
                return expr; 
            }
            else {
                Expression query = this.GetObjectQuery(member.DeclaringType, keyValues);
                Type elementType = System.Data.Linq.SqlClient.TypeSystem.GetElementType(query.Type); 
                ParameterExpression p = Expression.Parameter(elementType, "p");
                Expression e = p; 
                if (elementType != member.DeclaringType.Type) 
                    e = Expression.Convert(e, member.DeclaringType.Type);
                Expression mem = (member.Member is PropertyInfo) 
                    ? Expression.Property(e, (PropertyInfo)member.Member)
                    : Expression.Field(e, (FieldInfo)member.Member);
                LambdaExpression selector = Expression.Lambda(mem, p);
                return Expression.Call(typeof(Queryable), "Select", new Type[] { elementType, selector.Body.Type }, query, selector); 
            }
        } 
 
        private static Expression[] BuildKeyExpressions(object[] keyValues, ReadOnlyCollection<MetaDataMember> keyMembers) {
            Expression[] keyValueExpressions = new Expression[keyValues.Length]; 
            for (int i = 0, n = keyMembers.Count; i < n; i++) {
                MetaDataMember metaMember = keyMembers[i];
                Expression keyValueExpression = Expression.Constant(keyValues[i], metaMember.Type);
                keyValueExpressions[i] = keyValueExpression; 
            }
            return keyValueExpressions; 
        } 

        [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] 
        public IDeferredSourceFactory GetDeferredSourceFactory(MetaDataMember member) {
            if (member == null) {
                throw Error.ArgumentNull("member");
            } 
            IDeferredSourceFactory factory;
            if (this.factoryMap.TryGetValue(member, out factory)) { 
                return factory; 
            }
            Type elemType = member.IsAssociation && member.Association.IsMany 
                ? System.Data.Linq.SqlClient.TypeSystem.GetElementType(member.Type)
                : member.Type;
            factory = (IDeferredSourceFactory) Activator.CreateInstance(
                typeof(DeferredSourceFactory<>).MakeGenericType(elemType), 
                BindingFlags.Instance | BindingFlags.NonPublic, null,
                new object[] { member, this }, null 
                ); 
            this.factoryMap.Add(member, factory);
            return factory; 
        }

        class DeferredSourceFactory<T> : IDeferredSourceFactory {
            MetaDataMember member; 
            CommonDataServices services;
            ICompiledQuery query; 
            bool refersToPrimaryKey; 
            T[] empty;
 
            internal DeferredSourceFactory(MetaDataMember member, CommonDataServices services) {
                this.member = member;
                this.services = services;
                this.refersToPrimaryKey = this.member.IsAssociation && this.member.Association.OtherKeyIsPrimaryKey; 
                this.empty = new T[] { };
            } 
 
            public IEnumerable CreateDeferredSource(object instance) {
                if (instance == null) 
                    throw Error.ArgumentNull("instance");
                return new DeferredSource(this, instance);
            }
 
            public IEnumerable CreateDeferredSource(object[] keyValues) {
                if (keyValues == null) 
                    throw Error.ArgumentNull("keyValues"); 
                return new DeferredSource(this, keyValues);
            } 

            private IEnumerator<T> Execute(object instance) {
                ReadOnlyCollection<MetaDataMember> keys = null;
                if (this.member.IsAssociation) { 
                    keys = this.member.Association.ThisKey;
                } 
                else { 
                    keys = this.member.DeclaringType.IdentityMembers;
                } 
                object[] keyValues = new object[keys.Count];
                for (int i = 0, n = keys.Count; i < n; i++) {
                    object value = keys[i].StorageAccessor.GetBoxedValue(instance);
                    keyValues[i] = value; 
                }
 
                if (this.HasNullForeignKey(keyValues)) { 
                    return ((IEnumerable<T>)this.empty).GetEnumerator();
                } 

                T cached;
                if (this.TryGetCachedObject(keyValues, out cached)) {
                    return ((IEnumerable<T>)(new T[] { cached })).GetEnumerator(); 
                }
 
                if (this.member.LoadMethod != null) { 
                    try {
                        object result = this.member.LoadMethod.Invoke(this.services.Context, new object[] { instance }); 
                        if (typeof(T).IsAssignableFrom(this.member.LoadMethod.ReturnType)) {
                            return ((IEnumerable<T>)new T[] { (T)result }).GetEnumerator();
                        }
                        else { 
                            return ((IEnumerable<T>)result).GetEnumerator();
                        } 
                    } 
                    catch (TargetInvocationException tie) {
                        if (tie.InnerException != null) { 
                            throw tie.InnerException;
                        }
                        throw;
                    } 
                }
                else { 
                    return this.ExecuteKeyQuery(keyValues); 
                }
            } 

            private IEnumerator<T> ExecuteKeys(object[] keyValues) {
                if (this.HasNullForeignKey(keyValues)) {
                    return ((IEnumerable<T>)this.empty).GetEnumerator(); 
                }
 
                T cached; 
                if (this.TryGetCachedObject(keyValues, out cached)) {
                    return ((IEnumerable<T>)(new T[] { cached })).GetEnumerator(); 
                }

                return this.ExecuteKeyQuery(keyValues);
            } 

            private bool HasNullForeignKey(object[] keyValues) { 
                if (this.refersToPrimaryKey) { 
                    bool keyHasNull = false;
                    for (int i = 0, n = keyValues.Length; i < n; i++) { 
                        keyHasNull |= keyValues[i] == null;
                    }
                    if (keyHasNull) {
                        return true; 
                    }
                } 
                return false; 
            }
 
            private bool TryGetCachedObject(object[] keyValues, out T cached) {
                cached = default(T);
                if (this.refersToPrimaryKey) {
                    // look to see if we already have this object in the identity cache 
                    MetaType mt = this.member.IsAssociation ? this.member.Association.OtherType : this.member.DeclaringType;
                    object obj = this.services.GetCachedObject(mt, keyValues); 
                    if (obj != null) { 
                        cached = (T)obj;
                        return true; 
                    }
                }
                return false;
            } 

            private IEnumerator<T> ExecuteKeyQuery(object[] keyValues) { 
                if (this.query == null) { 
                    ParameterExpression p = Expression.Parameter(typeof(object[]), "keys");
                    Expression[] keyExprs = new Expression[keyValues.Length]; 
                    ReadOnlyCollection<MetaDataMember> members = this.member.IsAssociation ? this.member.Association.OtherKey : this.member.DeclaringType.IdentityMembers;
                    for (int i = 0, n = keyValues.Length; i < n; i++) {
                        MetaDataMember mm = members[i];
                        keyExprs[i] = Expression.Convert( 
#pragma warning disable 618 // Disable the 'obsolete' warning
                                          Expression.ArrayIndex(p, Expression.Constant(i)), 
#pragma warning restore 618 
                                          mm.Type
                                      ); 
                    }
                    Expression q = this.services.GetDataMemberQuery(this.member, keyExprs);
                    LambdaExpression lambda = Expression.Lambda(q, p);
                    this.query = this.services.Context.Provider.Compile(lambda); 
                }
                return ((IEnumerable<T>)this.query.Execute(this.services.Context.Provider, new object[] { keyValues }).ReturnValue).GetEnumerator(); 
            } 

            class DeferredSource : IEnumerable<T>, IEnumerable { 
                DeferredSourceFactory<T> factory;
                object instance;

                internal DeferredSource(DeferredSourceFactory<T> factory, object instance) { 
                    this.factory = factory;
                    this.instance = instance; 
                } 

                public IEnumerator<T> GetEnumerator() { 
                    object[] keyValues = this.instance as object[];
                    if (keyValues != null) {
                        return this.factory.ExecuteKeys(keyValues);
                    } 
                    return this.factory.Execute(this.instance);
                } 
 
                IEnumerator IEnumerable.GetEnumerator() {
                    return this.GetEnumerator(); 
                }
            }
        }
 
        /// <summary>
        /// Returns true if any objects have been added to the identity cache.  If 
        /// object tracking is disabled, this still returns true if any attempts 
        /// where made to cache an object.  Thus regardless of object tracking mode,
        /// this can be used as an indicator as to whether any result returning queries 
        /// have been executed.
        /// </summary>
        internal bool HasCachedObjects {
            get { 
                return this.hasCachedObjects;
            } 
        } 

        public object GetCachedObject(Expression query) { 
            if (query == null)
                return null;
            MethodCallExpression mc = query as MethodCallExpression;
            if (mc == null || mc.Arguments.Count < 1 || mc.Arguments.Count > 2) 
                return null;
            if (mc.Method.DeclaringType != typeof(Queryable)) { 
                return null; 
            }
            switch (mc.Method.Name) { 
                case "Where":
                case "First":
                case "FirstOrDefault":
                case "Single": 
                case "SingleOrDefault":
                    break; 
                default: 
                    return null;
            } 
            if (mc.Arguments.Count == 1) {
                // If it is something like
                //      context.Customers.Where(c => c.ID = 123).First()
                // then it is equivalent of 
                //      context.Customers.First(c => c.ID = 123)
                // hence reduce to context.Customers.Where(c => c.ID = 123) and process the remaining query 
                return GetCachedObject(mc.Arguments[0]); 
            }
            UnaryExpression quote = mc.Arguments[1] as UnaryExpression; 
            if (quote == null || quote.NodeType != ExpressionType.Quote)
                return null;
            LambdaExpression pred = quote.Operand as LambdaExpression;
            if (pred == null) 
                return null;
            ConstantExpression cex = mc.Arguments[0] as ConstantExpression; 
            if (cex == null) 
                return null;
            ITable t = cex.Value as ITable; 
            if (t == null)
                return null;
            Type elementType = System.Data.Linq.SqlClient.TypeSystem.GetElementType(query.Type);
            if (elementType != t.ElementType) 
                return null;
            MetaTable metaTable = this.metaModel.GetTable(t.ElementType); 
            object[] keyValues = this.GetKeyValues(metaTable.RowType, pred); 
            if (keyValues != null) {
                return this.GetCachedObject(metaTable.RowType, keyValues); 
            }
            return null;
        }
 
        internal object[] GetKeyValues(MetaType type, LambdaExpression predicate) {
            if (predicate == null) 
                throw Error.ArgumentNull("predicate"); 
            if (predicate.Parameters.Count != 1)
                return null; 
            Dictionary<MetaDataMember, object> keys = new Dictionary<MetaDataMember, object>();
            if (this.GetKeysFromPredicate(type, keys, predicate.Body)
                && keys.Count == type.IdentityMembers.Count) {
                object[] values = keys.OrderBy(kv => kv.Key.Ordinal).Select(kv => kv.Value).ToArray(); 
                return values;
            } 
            return null; 
        }
 
        private bool GetKeysFromPredicate(MetaType type, Dictionary<MetaDataMember, object> keys, Expression expr) {
            BinaryExpression bex = expr as BinaryExpression;
            if (bex == null) {
                MethodCallExpression mex = expr as MethodCallExpression; 
                if (mex != null && mex.Method.Name == "op_Equality" && mex.Arguments.Count == 2) {
                    bex = Expression.Equal(mex.Arguments[0], mex.Arguments[1]); 
                } 
                else {
                    return false; 
                }
            }
            switch (bex.NodeType) {
                case ExpressionType.And: 
                    return this.GetKeysFromPredicate(type, keys, bex.Left) &&
                           this.GetKeysFromPredicate(type, keys, bex.Right); 
                case ExpressionType.Equal: 
                    return GetKeyFromPredicate(type, keys, bex.Left, bex.Right) ||
                           GetKeyFromPredicate(type, keys, bex.Right, bex.Left); 
                default:
                    return false;
            }
        } 

        private static bool GetKeyFromPredicate(MetaType type, Dictionary<MetaDataMember, object> keys, Expression mex, Expression vex) { 
            MemberExpression memex = mex as MemberExpression; 
            if (memex == null || memex.Expression == null ||
                memex.Expression.NodeType != ExpressionType.Parameter || memex.Expression.Type != type.Type) { 
                return false;
            }
            if (!type.Type.IsAssignableFrom(memex.Member.ReflectedType) && !memex.Member.ReflectedType.IsAssignableFrom(type.Type)) {
                return false; 
            }
            MetaDataMember mm = type.GetDataMember(memex.Member); 
            if (!mm.IsPrimaryKey) { 
                return false;
            } 
            if (keys.ContainsKey(mm)) {
                return false;
            }
            ConstantExpression cex = vex as ConstantExpression; 
            if (cex != null) {
                keys.Add(mm, cex.Value); 
                return true; 
            }
            InvocationExpression ie = vex as InvocationExpression; 
            if (ie != null && ie.Arguments != null && ie.Arguments.Count == 0) {
                ConstantExpression ce = ie.Expression as ConstantExpression;
                if (ce != null) {
                    keys.Add(mm, ((Delegate)ce.Value).DynamicInvoke(new object[] {})); 
                    return true;
                } 
            } 
            return false;
        } 

        /// <summary>
        /// Either returns the object from cache if it is in cache, or
        /// queries for it. 
        /// </summary>
        internal object GetObjectByKey(MetaType type, object[] keyValues) { 
            // first check the cache 
            object target = GetCachedObject(type, keyValues);
            if (target == null) { 
                // no cached value, so query for it
                target = ((IEnumerable)this.context.Provider.Execute(this.GetObjectQuery(type, keyValues)).ReturnValue).OfType<object>().SingleOrDefault();
            }
            return target; 
        }
    } 
 
    internal struct RelatedItem {
        internal MetaType Type; 
        internal object Item;
        internal RelatedItem(MetaType type, object item) {
            this.Type = type;
            this.Item = item; 
        }
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.